home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacApp Release 10 / MacApp Release 10 - HD Ready / Libraries / App / Sources / UApplication.cp < prev    next >
Encoding:
Text File  |  1996-04-03  |  68.0 KB  |  2,348 lines  |  [TEXT/MPS ]
  1. //----------------------------------------------------------------------------------------
  2. // UApplication.cp 
  3. // Copyright © 1984-96 by Apple Computer, Inc. All rights reserved.
  4. //----------------------------------------------------------------------------------------
  5.  
  6. #ifndef __UAPPLICATION__
  7. #include "UApplication.h"
  8. #endif
  9.  
  10. // MacApp
  11.  
  12. #ifndef __UBEHAVIOR__
  13. #include "UBehavior.h"
  14. #endif
  15.  
  16. #ifndef __UBUSYCURSOR__
  17. #include "UBusyCursor.h"
  18. #endif
  19.  
  20. #ifndef __UCLIPBOARDMGR__
  21. #include "UClipboardMgr.h"
  22. #endif
  23.  
  24. #if qContainer
  25.     #ifndef __UCONTAINER__
  26.     #include "UContainer.h"
  27.     #endif
  28. #endif
  29.  
  30. #ifndef __UDEBUG__
  31. #include "UDebug.h"
  32. #endif
  33.  
  34. #if qDebug
  35.     #ifndef __UDEBUGVIEW__
  36.     #include "UDebugView.h"
  37.     #endif
  38. #endif
  39.  
  40. #ifndef __UDEPENDENCIES__
  41. #include "UDependencies.h"
  42. #endif
  43.  
  44. #ifndef __UDESIGNATOR__
  45. #include "UDesignator.h"
  46. #endif
  47.  
  48. #ifndef __UDOCUMENT__
  49. #include "UDocument.h"
  50. #endif
  51.  
  52. #ifndef __UERRORMGR__
  53. #include "UErrorMgr.h"
  54. #endif
  55.  
  56. #ifndef __UFILE__
  57. #include "UFile.h"
  58. #endif
  59.  
  60. #ifndef __FLOATWINDOW__
  61. #include "FloatWindow.h"
  62. #endif
  63.  
  64. #ifndef __UGEOMETRY__
  65. #include "UGeometry.h"
  66. #endif
  67.  
  68. #ifndef __UMACAPPGLOBALS__
  69. #include "UMacAppGlobals.h"
  70. #endif
  71.  
  72. #ifndef __UMACAPPUTILITIES__
  73. #include "UMacAppUtilities.h"
  74. #endif
  75.  
  76. #if qPowerTalk
  77.     #ifndef __UMAILABLE__
  78.     #include "UMailable.h"
  79.     #endif
  80. #endif
  81.  
  82. #ifndef __UMEMORY__
  83. #include "UMemory.h"
  84. #endif
  85.  
  86. #ifndef __UMENUMGR__
  87. #include "UMenuMgr.h"
  88. #endif
  89.  
  90. #ifndef __UPATCH__
  91. #include "UPatch.h"
  92. #endif
  93.  
  94. #ifndef __UPERFORM__
  95. #include "UPerform.h"
  96. #endif
  97.  
  98. #ifndef __UPRINTHANDLER__
  99. #include "UPrintHandler.h"
  100. #endif
  101.  
  102. #ifndef __UOSASCRIPT__
  103. #include "UOSAScript.h"
  104. #endif
  105.  
  106. #ifndef __USCRIPTING__
  107. #include "UScripting.h"
  108. #endif
  109.  
  110. #ifndef __USECTIONMGR__
  111. #include "USectionMgr.h"
  112. #endif
  113.  
  114. #ifndef __USEGMENTS__
  115. #include "USegments.h"
  116. #endif
  117.  
  118. #ifndef __USTREAM__
  119. #include "UStream.h"
  120. #endif
  121.  
  122. #ifndef __UTABBEHAVIORS__
  123. #include "UTabBehaviors.h"
  124. #endif
  125.  
  126. #ifndef __UVIEWSERVER__
  127. #include "UViewServer.h"
  128. #endif
  129.  
  130. #if qNeedsVU
  131.     #ifndef __UVUASSIST__
  132.     #include "UVUAssist.h"
  133.     #endif
  134. #endif
  135.  
  136. #ifndef __UWINDOW__
  137. #include "UWindow.h"
  138. #endif
  139.  
  140. // CALib
  141.  
  142. #if qContainer
  143.     #ifndef _CALIB_
  144.     #include "CALib.h"
  145.     #endif
  146. #endif
  147.  
  148. // Toolbox
  149.  
  150. #ifndef __AEREGISTRY__
  151. #include <AERegistry.h>
  152. #endif
  153.  
  154. #ifndef __DEVICES__
  155. #include <Devices.h>
  156. #endif
  157.  
  158. #ifndef __DISKINIT__
  159. #include <DiskInit.h>
  160. #endif
  161.  
  162. #ifndef __ERRORS__
  163. #include <Errors.h>
  164. #endif
  165.  
  166. #ifndef __LOWMEM__
  167. #include <LowMem.h>
  168. #endif
  169.  
  170. #ifndef __RESOURCES__
  171. #include <Resources.h>
  172. #endif
  173.  
  174. #ifndef __TOOLUTILS__
  175. #include <ToolUtils.h>
  176. #endif
  177.  
  178. // ANSI
  179.  
  180. #ifndef __STDIO__
  181. #include <stdio.h>
  182. #endif
  183.  
  184. // Other
  185.  
  186. #if defined(__MWERKS__) && (qDebug || qTheDebugger)
  187.     #ifndef __CWDEBUG__
  188.         #include "CWDebug.h"
  189.     #endif    
  190. #endif
  191.  
  192. //----------------------------------------------------------------------------------------
  193. // Constant definitions
  194. //----------------------------------------------------------------------------------------
  195.  
  196. enum SystemJustification { smSysJustLeft = 0, smSysJustRight = -1 };
  197.     // Constants to use with GetSysDirection() and SetSysDirection().
  198.  
  199.  
  200. //----------------------------------------------------------------------------------------
  201. // Global variable definitions.
  202. //----------------------------------------------------------------------------------------
  203.  
  204. TApplication* gApplication;
  205. //Boolean gInitialized;
  206. //AEAddressDesc gServerAddress;
  207.  
  208.  
  209. Boolean hadCreditsStringList;        // does the rsrc 'STR#' == kDefaultCredits exist ?
  210. short lastCreditsStringIndex;        // the last CString in the STR# to be displayed
  211. long lastCreditsShownTicks;            // the tickcount when the last Credit was Shown
  212. CStringHandle originalText;            // the about box's original text (prior to credits)
  213. short waitTicks;                    // how long to wait between credits 
  214.  
  215. //========================================================================================
  216. // GLOBAL Procedures
  217. //========================================================================================
  218. static pascal Boolean DoShowAboutAppFilter(DialogRef theDialog,
  219.                                            EventRecord& theEvent,
  220.                                            short& itemHit);
  221. static void DoSetupTheMenus(void* yourDataPtr);
  222.  
  223. static WindowRef GetWindowToClose();
  224.  
  225. #undef Inherited
  226.  
  227. //----------------------------------------------------------------------------------------
  228. // DoShowAboutAppFilter: 
  229. //----------------------------------------------------------------------------------------
  230. #pragma segment MAAboutApp
  231.  
  232. pascal Boolean DoShowAboutAppFilter(DialogRef theDialog,
  233.                                     EventRecord& theEvent,
  234.                                     short& itemHit)
  235. {
  236.     CStr255 s;
  237.     CStr255 originalStr;
  238.     Handle item;
  239.     Boolean returnValue = FALSE;
  240.     short itemType;
  241.     CRect box;
  242.  
  243.     switch (theEvent.what)
  244.     {
  245.         case keyDown:
  246.             switch ((unsigned char)(((theEvent.message) & charCodeMask)))
  247.             {
  248.                 case chEnter:
  249.                 case chReturn:
  250.                     DoAlertKeyDown(theDialog, ok);
  251.                     break;
  252.             }
  253.             break;
  254.  
  255.         case nullEvent:
  256.             if ((TickCount() - lastCreditsShownTicks) > waitTicks)
  257.             {
  258.                 short itemNo = 1;
  259.  
  260.                 do
  261.                 {
  262.                     item = NULL;
  263.                     GetDialogItem(theDialog, itemNo, &itemType, &item, box);
  264.                     if (((itemType) & 0x7F) == statText)// we don't care if its enabled or not 
  265.                         break;
  266.                     else
  267.                         ++itemNo;
  268.                 } while (item);
  269.  
  270.                 GetIndString(s, kDefaultCredits, lastCreditsStringIndex);
  271.  
  272.                 if (!s.IsEmpty())
  273.                 {
  274.                     // save the original text 
  275.                     if ((lastCreditsStringIndex == 1) && ((*originalText)->IsEmpty() && item))
  276.                     {
  277.                         GetDialogItemText(item, originalStr);
  278.                         SetString((StringHandle)originalText, (ConstStr255Param)&originalStr);
  279.                     }
  280.                     ++lastCreditsStringIndex;
  281.                     lastCreditsShownTicks = TickCount();
  282.                     if (item)
  283.                         SetDialogItemText(item, s);
  284.                     waitTicks = (short)Min((s.Length() * 6), 60);
  285.                 }
  286.                 else                            // no more items 
  287.                     {
  288.                         lastCreditsStringIndex = 1;
  289.                         lastCreditsShownTicks = TickCount();
  290.                         if (item)
  291.                         {
  292.                             originalStr = **originalText;
  293.                             SetDialogItemText(item, originalStr);
  294.                         }
  295.                         waitTicks = 6 * 60;
  296.                     }
  297.             }
  298.             break;
  299.     } // switch
  300.  
  301.     // Forward on to the standard filter 
  302.     if (gMacAppAlertFilter)
  303.         returnValue = ((ModalFilterProcPtr)gMacAppAlertFilter)(theDialog, &theEvent, &itemHit);
  304.  
  305.     return returnValue;
  306. } // DoShowAboutAppFilter 
  307.  
  308. //========================================================================================
  309. // CLASS TQuitCommand
  310. //========================================================================================
  311. #undef Inherited
  312. #define Inherited TCommand
  313.  
  314. #pragma segment MAApplicationRes
  315. MA_DEFINE_CLASS_M1(TQuitCommand, Inherited);
  316.  
  317. //----------------------------------------------------------------------------------------
  318. // TQuitCommand: Empty constructor to satisfy the compiler.
  319. //----------------------------------------------------------------------------------------
  320. #pragma segment ConstructorRes
  321.  
  322. TQuitCommand::TQuitCommand()
  323.     : fRespondingToAE(FALSE),
  324.       fInProcessP(NULL),
  325.       fMessage(NULL),
  326.       fReply(NULL)
  327. {
  328. } // TQuitCommand::TQuitCommand
  329.  
  330. //----------------------------------------------------------------------------------------
  331. // TQuitCommand destructor
  332. //----------------------------------------------------------------------------------------
  333. #pragma segment MADestructorRes
  334.  
  335. TQuitCommand::~TQuitCommand()
  336. {
  337.     if (fInProcessP != NULL)
  338.         *fInProcessP = FALSE;
  339. }
  340.  
  341. //----------------------------------------------------------------------------------------
  342. // TQuitCommand::IQuitCommand: 
  343. //----------------------------------------------------------------------------------------
  344. #pragma segment MASelCommand
  345.  
  346. void TQuitCommand::IQuitCommand(CommandNumber itsCommandNumber, Boolean* statusP)
  347. {
  348.     this->ICommand(itsCommandNumber, gApplication, kCantUndo,
  349.                    kDoesNotCauseChange, NULL);
  350.     
  351.     fPriority++;        // Lower our priority.
  352.     fInProcessP = statusP;
  353.     if (fInProcessP != NULL)
  354.         *fInProcessP = TRUE;
  355. } 
  356.  
  357. //----------------------------------------------------------------------------------------
  358. // TQuitCommand::IQuitCommand: 
  359. //----------------------------------------------------------------------------------------
  360. #pragma segment MASelCommand
  361.  
  362. void TQuitCommand::IQuitCommand(TAppleEvent* message ,
  363.                                 TAppleEvent* reply,
  364.                                 Boolean* statusP)
  365. {
  366.     this->ICommand(cQuit, gApplication, kCantUndo,
  367.                    kDoesNotCauseChange, NULL);
  368.  
  369.     fMessage = message;
  370.     fReply = reply;
  371.     fPriority++;        // Lower our priority.
  372.     fInProcessP = statusP;
  373.     if (fInProcessP != NULL)
  374.         *fInProcessP = TRUE;
  375.  
  376.     fRespondingToAE = TRUE;
  377. } 
  378.  
  379. //----------------------------------------------------------------------------------------
  380. // TQuitCommand::IsReadyToExecute: 
  381. //----------------------------------------------------------------------------------------
  382. #pragma segment MAApplicationRes
  383.  
  384. Boolean TQuitCommand::IsReadyToExecute()    // Override
  385. {
  386.     // Don't execute Quit if application has a dialog posed modally!
  387.     if (gApplication->InModalState())
  388.         return FALSE;
  389.     else
  390.         return fReadyToExecute;
  391. }
  392.  
  393. //----------------------------------------------------------------------------------------
  394. // TQuitCommand::DoIt: 
  395. //----------------------------------------------------------------------------------------
  396. #pragma segment MAApplicationRes
  397.  
  398. void TQuitCommand::DoIt()
  399. {
  400.     FailInfo fi;
  401.     Try(fi)
  402.     {
  403.         // Close all windows and documents in window order then close
  404.         // all documentless windows.  Finally, shut down the application.
  405.         DoCloseInWindowOrder();
  406.         DoCloseWindowlessDocuments();
  407.         DoCloseApplication();
  408.         
  409.         fi.Success();
  410.     }
  411.     else
  412.     {
  413.         if (fRespondingToAE)
  414.             fi.ReSignal();
  415.         else if (fi.error != userCanceledErr)
  416.             gApplication->ShowError(fi.error, 0);
  417.     }
  418. } // TQuitCommand::DoIt 
  419.  
  420. //----------------------------------------------------------------------------------------
  421. // GetWindowToClose: 
  422. //----------------------------------------------------------------------------------------
  423. #pragma segment MAUtilitiesRes
  424.  
  425. WindowRef GetWindowToClose()
  426. {
  427.     WindowRef currentWindow = (WindowRef)LMGetWindowList();
  428.     Boolean found = FALSE;
  429.     while (currentWindow && !found)
  430.     {
  431.         if (currentWindow != gWorkPort)
  432.         {
  433.             TWindow* aWindow = gApplication->WMgrToWindow(currentWindow);
  434.             if (aWindow)
  435.                 found = aWindow->fFreeOnClosing || aWindow->IsShown();
  436.             else
  437.                 found = TRUE;
  438.         }
  439.         if (!found)
  440.             currentWindow = GetNextWindow(currentWindow);
  441.     }
  442.     return currentWindow;
  443. }
  444.  
  445. //----------------------------------------------------------------------------------------
  446. // TQuitCommand::DoCloseInWindowOrder: 
  447. //----------------------------------------------------------------------------------------
  448. #pragma segment MAApplicationRes
  449.  
  450. void TQuitCommand::DoCloseInWindowOrder()
  451. {
  452.     // This will iterate through all open windows and will close the associated
  453.     // document if there is one or will close the window if there is no document.
  454.     // (Ghost documents are not closed here.  But their windows are.)
  455.     WindowRef aWindowPtr;
  456.     while ((aWindowPtr = GetWindowToClose()) != NULL)
  457.     {
  458.         TWindow* aWindow = gApplication->WMgrToWindow(aWindowPtr);
  459.         if (aWindow)
  460.         {
  461.             TDocument* windowsDocument = aWindow->fDocument;
  462.             if (windowsDocument != NULL && !windowsDocument->GetIsGhostDocument())
  463.                 CloseADocument(windowsDocument);
  464.             else
  465.                 CloseAWindow(aWindow);
  466.         }
  467.         else
  468.             gApplication->CloseToolboxWindow(aWindowPtr);
  469.     }
  470. } 
  471.  
  472. //----------------------------------------------------------------------------------------
  473. // TQuitCommand::DoCloseWindowlessDocuments: 
  474. //----------------------------------------------------------------------------------------
  475. #pragma segment MAApplicationRes
  476.  
  477. void TQuitCommand::DoCloseWindowlessDocuments()
  478. {
  479.     // This really doesn't care if the document is windowless or not, it's
  480.     // just that all documents with windows should have been closed by now.
  481.     CNoGhostDocsIterator iter(gApplication);
  482.     
  483.     for (TDocument* aDocument = iter.FirstDocument();
  484.              iter.More(); aDocument = iter.NextDocument())
  485.     {
  486.         // Closing the document will close any associated windows.
  487.         MAVolatileInit(TCloseDocCommand*, aCloseCommand, NULL);
  488.         MAVolatileInit(Boolean, oldTempAlloc, TemporaryAllocation(TRUE));
  489.         MAVolatileInit(Boolean, oldObjectPerm, AllocateObjectsFromPerm(FALSE));
  490.     
  491.         FailInfo fi;
  492.         Try(fi)
  493.         {
  494.             aCloseCommand = aDocument->MakeCloseCommand();
  495.             if (fRespondingToAE)
  496.                 aCloseCommand->fUseAppleEvent = FALSE;
  497.             aCloseCommand->Process();
  498.  
  499.             TemporaryAllocation(oldTempAlloc);
  500.             AllocateObjectsFromPerm(oldObjectPerm);
  501.     
  502.             fi.Success();
  503.         }
  504.         else                                // Recover
  505.         {
  506.             TemporaryAllocation(oldTempAlloc);
  507.             AllocateObjectsFromPerm(oldObjectPerm);
  508.             fi.ReSignal();
  509.         }
  510.     }
  511. }
  512.  
  513. //----------------------------------------------------------------------------------------
  514. // TQuitCommand::CloseAWindow: 
  515. //----------------------------------------------------------------------------------------
  516. #pragma segment MAApplicationRes
  517.  
  518. void TQuitCommand::CloseAWindow(TWindow* aWindow)
  519. {
  520.     Boolean record = !fRespondingToAE
  521.                      && (gClipboardMgr->fClipWindow != aWindow)
  522.                      && aWindow->IsShown();
  523.     MAVolatileInit(TCloseWindowCommand*, aCloseWindowCommand, NULL);
  524.     MAVolatileInit(Boolean, oldTempAlloc, TemporaryAllocation(TRUE));
  525.     MAVolatileInit(Boolean, oldObjectPerm, AllocateObjectsFromPerm(FALSE));
  526.  
  527.     FailInfo fi;
  528.     Try(fi)
  529.     {
  530.         aCloseWindowCommand = new TCloseWindowCommand;
  531.         aCloseWindowCommand->ICloseWindowCommand(cClose, aWindow);
  532.         if (!record)
  533.             aCloseWindowCommand->fUseAppleEvent = FALSE;
  534.         aCloseWindowCommand->Process();
  535.  
  536.         TemporaryAllocation(oldTempAlloc);
  537.         AllocateObjectsFromPerm(oldObjectPerm);
  538.  
  539.         fi.Success();
  540.     }
  541.     else                                // Recover
  542.     {
  543.         TemporaryAllocation(oldTempAlloc);
  544.         AllocateObjectsFromPerm(oldObjectPerm);
  545.  
  546.         fi.ReSignal();
  547.     }
  548. } 
  549.  
  550. //----------------------------------------------------------------------------------------
  551. // TQuitCommand::DoCloseDocuments: 
  552. //----------------------------------------------------------------------------------------
  553. #pragma segment MAApplicationRes
  554.  
  555. void TQuitCommand::CloseADocument(TDocument* aDocument)
  556. {
  557.     // Closing the document will close any associated windows.
  558.     MAVolatileInit(TCloseDocCommand*, aCloseCommand, NULL);
  559.     MAVolatileInit(Boolean, oldTempAlloc, TemporaryAllocation(TRUE));
  560.     MAVolatileInit(Boolean, oldObjectPerm, AllocateObjectsFromPerm(FALSE));
  561.  
  562.     FailInfo fi;
  563.     Try(fi)
  564.     {
  565.         aCloseCommand = aDocument->MakeCloseCommand();
  566.         if (fRespondingToAE)
  567.             aCloseCommand->fUseAppleEvent = FALSE;
  568.         aCloseCommand->Process();
  569.  
  570.         TemporaryAllocation(oldTempAlloc);
  571.         AllocateObjectsFromPerm(oldObjectPerm);
  572.  
  573.         fi.Success();
  574.     }
  575.     else                                // Recover
  576.     {
  577.         TemporaryAllocation(oldTempAlloc);
  578.         AllocateObjectsFromPerm(oldObjectPerm);
  579.  
  580.         fi.ReSignal();
  581.     }
  582. }
  583.  
  584. //----------------------------------------------------------------------------------------
  585. // TQuitCommand::DoCloseApplication: 
  586. //----------------------------------------------------------------------------------------
  587. #pragma segment MAApplicationRes
  588.  
  589. void TQuitCommand::DoCloseApplication()
  590. {
  591.     // Final Stage: We're ready to do the final shutdown now that 
  592.     // all windows and documents have been closed.
  593.     Boolean oldTempAlloc = TemporaryAllocation(TRUE);
  594.     Boolean oldObjectPerm = AllocateObjectsFromPerm(FALSE);
  595.     
  596.     TQuitAppCommand* aQuitAppCommand = new TQuitAppCommand;
  597.     aQuitAppCommand->IQuitAppCommand(cQuit);
  598.     if (fRespondingToAE)
  599.         aQuitAppCommand->fUseAppleEvent = FALSE;
  600.     aQuitAppCommand->Process();
  601.     
  602.     TemporaryAllocation(oldTempAlloc);
  603.     AllocateObjectsFromPerm(oldObjectPerm);
  604. }
  605.  
  606. //========================================================================================
  607. // CLASS TQuitAppCommand
  608. //========================================================================================
  609. #undef Inherited
  610. #define Inherited TCommand
  611.  
  612. #pragma segment MAApplicationRes
  613. MA_DEFINE_CLASS_M1(TQuitAppCommand, Inherited);
  614.  
  615. //----------------------------------------------------------------------------------------
  616. // TQuitAppCommand constructor
  617. //----------------------------------------------------------------------------------------
  618. #pragma segment ConstructorRes
  619.  
  620. TQuitAppCommand::TQuitAppCommand()
  621. {
  622. } // TQuitAppCommand::TQuitAppCommand
  623.  
  624. //----------------------------------------------------------------------------------------
  625. // TQuitAppCommand destructor
  626. //----------------------------------------------------------------------------------------
  627. #pragma segment MADestructorRes
  628.  
  629. TQuitAppCommand::~TQuitAppCommand()
  630. {
  631. }
  632.  
  633. //----------------------------------------------------------------------------------------
  634. // TQuitAppCommand::IQuitAppCommand: 
  635. //----------------------------------------------------------------------------------------
  636. #pragma segment MASelCommand
  637.  
  638. void TQuitAppCommand::IQuitAppCommand(CommandNumber itsCommandNumber)
  639. {
  640.     this->ICommand(itsCommandNumber, gApplication, kCantUndo, kDoesNotCauseChange, NULL);
  641. } 
  642.  
  643. //----------------------------------------------------------------------------------------
  644. // TQuitAppCommand::MakeAppleEvent: 
  645. //----------------------------------------------------------------------------------------
  646. #pragma segment MAApplicationRes
  647.  
  648. TAppleEvent* TQuitAppCommand::MakeAppleEvent()
  649. {
  650.     MAVolatileInit(TAppleEvent*, mayFailEvent, NULL);
  651.  
  652.     FailInfo fi;
  653.     Try(fi)
  654.     {
  655.         CAEDesc mySpecifier;
  656.         TAppleEvent*    theEvent = new TAppleEvent;
  657.         theEvent->IAppleEvent(kCoreEventClass, kAEQuitApplication, gServerAddress, kAEWaitReply);
  658.         mayFailEvent = theEvent;
  659.         gApplication->MakeObjectSpecifier(mySpecifier, formName);
  660.         theEvent->WriteParameter(keyDirectObject, mySpecifier);
  661.         fi.Success();
  662.     }
  663.     else // Recover
  664.     {
  665.         mayFailEvent = (TAppleEvent*)FreeIfObject(mayFailEvent);
  666.         fi.ReSignal();
  667.     }
  668.     
  669.     return mayFailEvent;
  670. }    
  671.  
  672. //----------------------------------------------------------------------------------------
  673. // TQuitAppCommand::IsReadyToExecute: 
  674. //----------------------------------------------------------------------------------------
  675. #pragma segment MAApplicationRes
  676.  
  677. Boolean TQuitAppCommand::IsReadyToExecute()    // Override
  678. {
  679.     // Don't execute Quit if application has a dialog posed modally!
  680.     if (gApplication->InModalState())
  681.         return FALSE;
  682.     else
  683.         return fReadyToExecute;
  684. }
  685.  
  686. //----------------------------------------------------------------------------------------
  687. // TQuitAppCommand::DoIt: 
  688. //----------------------------------------------------------------------------------------
  689. #pragma segment MAApplicationRes
  690.  
  691. void TQuitAppCommand::DoIt()
  692. {
  693.     FailInfo fi;
  694.     Try(fi)
  695.     {
  696.         gApplication->fDone = TRUE;
  697.         gApplication->Close();
  698.         fi.Success();
  699.     }
  700.     else // Recover
  701.     {
  702.         gApplication->fDone = FALSE;
  703.         fi.ReSignal();
  704.     }
  705. } // TQuitAppCommand::DoIt 
  706.  
  707. //========================================================================================
  708. // CLASS TNewDocumentCommand
  709. //========================================================================================
  710. #undef Inherited
  711. #define Inherited TCommand
  712.  
  713. #pragma segment MAOpen
  714. MA_DEFINE_CLASS_M1(TNewDocumentCommand, Inherited);
  715.  
  716. //----------------------------------------------------------------------------------------
  717. // TNewDocumentCommand: Empty constructor to satisfy the compiler.
  718. //----------------------------------------------------------------------------------------
  719. #pragma segment ConstructorRes
  720.  
  721. TNewDocumentCommand::TNewDocumentCommand()
  722. {
  723. } // TNewDocumentCommand::TNewDocumentCommand
  724.  
  725. //----------------------------------------------------------------------------------------
  726. // TNewDocumentCommand destructor
  727. //----------------------------------------------------------------------------------------
  728. #pragma segment MADestructorRes
  729.  
  730. TNewDocumentCommand::~TNewDocumentCommand()
  731. {
  732. }
  733.  
  734. //----------------------------------------------------------------------------------------
  735. // TNewDocumentCommand::DoIt: 
  736. //----------------------------------------------------------------------------------------
  737. #pragma segment MAOpen
  738.  
  739. void TNewDocumentCommand::DoIt()
  740. {
  741.     gApplication->OpenNew(fIdentifier);
  742. } // TNewDocumentCommand::DoIt 
  743.  
  744. //----------------------------------------------------------------------------------------
  745. // TNewDocumentCommand::INewDocumentCommand: 
  746. //----------------------------------------------------------------------------------------
  747. #pragma segment MASelCommand
  748.  
  749. void TNewDocumentCommand::INewDocumentCommand(CommandNumber itsCommandNumber)
  750. {
  751.     this->ICommand(itsCommandNumber, gApplication, kCantUndo, kDoesNotCauseChange, NULL);
  752. } // TNewDocumentCommand::INewDocumentCommand 
  753.  
  754. //----------------------------------------------------------------------------------------
  755. // TNewDocumentCommand::MakeAppleEvent: 
  756. //----------------------------------------------------------------------------------------
  757. #pragma segment MACommandRes
  758.  
  759. TAppleEvent* TNewDocumentCommand::MakeAppleEvent()
  760. {
  761.     // Create a recordable apple event
  762.     TAppleEvent * theEvent = NULL;
  763.     CTempDesc theAppDesc;
  764.  
  765.     gApplication->MakeObjectSpecifier(theAppDesc);
  766.     
  767.     theEvent = TAppleEvent::MakeCreateElementEvent(gServerAddress, kAEWaitReply,
  768.         theAppDesc, cDocument, kAEBeginning, CAEDesc::fgNullDesc, CAEDesc::fgNullDesc);
  769.     return theEvent;
  770. }
  771.  
  772. //========================================================================================
  773. // CLASS TFilesCommand
  774. //========================================================================================
  775. #undef Inherited
  776. #define Inherited TServerCommand
  777.  
  778. #pragma segment MASelCommand
  779. MA_DEFINE_CLASS_M1(TFilesCommand, Inherited);
  780.  
  781. //----------------------------------------------------------------------------------------
  782. // TFilesCommand constructor
  783. //----------------------------------------------------------------------------------------
  784. #pragma segment MASelCommand
  785.  
  786. TFilesCommand::TFilesCommand()
  787. {
  788.     fCausesChange = FALSE;
  789.     fFileList = NULL;
  790. #if qPowerTalk
  791.     fOpenLetters = FALSE;
  792. #endif
  793. } // TFilesCommand::TFilesCommand
  794.  
  795. //----------------------------------------------------------------------------------------
  796. // TFilesCommand::Free: 
  797. //----------------------------------------------------------------------------------------
  798. #pragma segment MAClose
  799.  
  800. TFilesCommand::~TFilesCommand()
  801. {
  802.     fFileList = (TList*)FreeListIfObject(fFileList);
  803. } // TFilesCommand::Free 
  804.  
  805.  
  806. //----------------------------------------------------------------------------------------
  807. // TFilesCommand::IFilesCommand: 
  808. //----------------------------------------------------------------------------------------
  809. #pragma segment MASelCommand
  810.  
  811. void TFilesCommand::IFilesCommand(CommandNumber itsCommandNumber,
  812.                                   TList* theDocuments)
  813. {
  814.     this->IServerCommand(itsCommandNumber, gApplication, kCantUndo, kDoesNotCauseChange, NULL);
  815.     fFileList = theDocuments;
  816. } // TFilesCommand::IFilesCommand 
  817.  
  818. //----------------------------------------------------------------------------------------
  819. // TFilesCommand::IFilesCommand: 
  820. //----------------------------------------------------------------------------------------
  821. #pragma segment MASelCommand
  822.  
  823. void TFilesCommand::IFilesCommand(CommandNumber itsCommandNumber,
  824.                                   const AppleEvent& itsMessage,
  825.                                   const AppleEvent& itsReply)    // override 
  826. {
  827.     IServerCommand(itsCommandNumber, gApplication, kCantUndo, kDoesNotCauseChange, NULL,
  828.                    itsMessage, itsReply);
  829.  
  830.     // Check to see what is in the direct object list
  831.     this->GetFilesList();
  832. } // TFilesCommand::IFilesCommand 
  833.  
  834. //----------------------------------------------------------------------------------------
  835. // TFilesCommand::GetFilesList: 
  836. //----------------------------------------------------------------------------------------
  837. #pragma segment MASelCommand
  838.  
  839. void TFilesCommand::GetFilesList()
  840. {
  841.     // Check to see what is in the direct object list
  842.     CAEDesc directObj;
  843.     FailOSErr(AEGetParamDesc(&fMessage->fMessage, keyDirectObject, typeAEList, directObj));
  844.     long theCount = 0;
  845.     FailOSErr(AECountItems(directObj, &theCount));
  846.     if (theCount > 0)
  847.     {
  848.         // Get the first descriptor and see what type it is
  849.         DescType theKey;
  850.         CTempDesc theDesc;
  851.         FailOSErr(AEGetNthDesc(directObj, 1, typeWildCard, &theKey, theDesc));
  852. #if qPowerTalk
  853.         // ••• should notify user that powertalk is not available
  854.         fOpenLetters = (theDesc.GetDescriptorType() == typeLetterDesc);
  855. #endif
  856.     }
  857.  
  858. #if qPowerTalk
  859.     if (fOpenLetters)
  860.     {
  861.         fIdentifier = cOpenLetter;
  862.         fLetterList = directObj;
  863.     }
  864.     else
  865. #endif
  866.     {
  867.         MAVolatileInit(THandleList*, aHandleList, NULL);
  868.         MAVolatileInit(TList*, aFileList, NULL);
  869.         
  870.         FailInfo outerFi;
  871.         Try(outerFi)
  872.         {
  873.             aHandleList = new THandleList;
  874.             aHandleList->IHandleList();
  875.     
  876.             FailInfo innerfi;
  877.             Try(innerfi)
  878.             {
  879.                 aFileList = NewList();
  880.         
  881.                 fMessage->ReadHandleList(keyDirectObject, typeAlias, aHandleList);
  882.         
  883.                 // Block is necessary for correct failure handling
  884.                 {
  885.                     CHandleIterator iter(aHandleList);
  886.         
  887.                     for (Handle item = iter.FirstHandle(); iter.More(); item = iter.NextHandle())
  888.                     {
  889.                         MAVolatileInit(TFile*, aFile, NULL);
  890.         
  891.                         aFile = gApplication->DoMakeFile(fIdentifier);
  892.     
  893.                         FailInfo onemorefi;
  894.                         Try(onemorefi)
  895.                         {
  896.                             FailOSErr(aFile->SpecifyWithAlias(AliasHandle(item)));
  897.                             aFileList->InsertLast(aFile);
  898.                             onemorefi.Success();
  899.                         }
  900.                         else
  901.                         {
  902.                             aFile = (TFile*)FreeIfObject(aFile);
  903.                             onemorefi.ReSignal();
  904.                         }
  905.                         
  906.                         aHandleList->Delete(item);        // Delete it from the list so if we fail
  907.                                                         // we don't try to free it twice
  908.                         item = DisposeIfHandle(item);
  909.                     }
  910.                 }
  911.                 innerfi.Success();
  912.             }
  913.             else                                        // Recover
  914.             {
  915.                 if (aHandleList)
  916.                     aHandleList->FreeList();
  917.                     
  918.                 if (aFileList)
  919.                     aFileList->FreeList();
  920.             
  921.                 innerfi.ReSignal();
  922.             }
  923.             outerFi.Success();
  924.         }
  925.         else
  926.         {
  927.             this->Free();
  928.             outerFi.ReSignal();
  929.         }
  930.     
  931.         aHandleList->Free();                        // It is just a list of disposed handles…
  932.     
  933.         fFileList = aFileList;
  934.         directObj.DisposeDesc();
  935.     }
  936.  
  937. } // TFilesCommand::IFilesCommand 
  938.  
  939. //========================================================================================
  940. // CLASS TODocCommand
  941. //========================================================================================
  942. #undef Inherited
  943. #define Inherited TFilesCommand
  944.  
  945. #pragma segment MASelCommand
  946. MA_DEFINE_CLASS_M1(TODocCommand, Inherited);
  947.  
  948. //----------------------------------------------------------------------------------------
  949. // TODocCommand: Empty constructor to satisfy the compiler.
  950. //----------------------------------------------------------------------------------------
  951. #pragma segment ConstructorRes
  952.  
  953. TODocCommand::TODocCommand()
  954. {
  955. } // TODocCommand::TODocCommand
  956.  
  957. //----------------------------------------------------------------------------------------
  958. // TODocCommand destructor
  959. //----------------------------------------------------------------------------------------
  960. #pragma segment MADestructorRes
  961.  
  962. TODocCommand::~TODocCommand()
  963. {
  964. }
  965.  
  966. //----------------------------------------------------------------------------------------
  967. // TODocCommand::IODocCommand: 
  968. //----------------------------------------------------------------------------------------
  969. #pragma segment MASelCommand
  970.  
  971. void TODocCommand::IODocCommand(CommandNumber itsCommandNumber,
  972.                                 TList* theDocuments)
  973. {
  974.     this->IFilesCommand(itsCommandNumber, theDocuments);
  975. } // TODocCommand::IODocCommand 
  976.  
  977. //----------------------------------------------------------------------------------------
  978. // TODocCommand::IODocCommand: 
  979. //----------------------------------------------------------------------------------------
  980. #pragma segment MASelCommand
  981.  
  982. void TODocCommand::IODocCommand(CommandNumber itsCommandNumber,
  983.                                 const AppleEvent& itsMessage,
  984.                                 const AppleEvent& itsReply)
  985. {
  986.     this->IFilesCommand(itsCommandNumber, itsMessage, itsReply);
  987. } // TODocCommand::IODocCommand 
  988.  
  989. //----------------------------------------------------------------------------------------
  990. // TODocCommand::DoIt: 
  991. //----------------------------------------------------------------------------------------
  992. #pragma segment MAOpen
  993.  
  994. void TODocCommand::DoIt()                // override 
  995. {
  996.     FailInfo fi;
  997. //    Try(fi)
  998. //    {
  999. #if qPowerTalk
  1000.     if (fOpenLetters && HasAOCEToolBox())
  1001.     {
  1002.         if (gMailing)
  1003.             gMailing->OpenOldLetters(fIdentifier, fLetterList);
  1004.     }
  1005.     else
  1006. #endif
  1007.         gApplication->OpenOld(fIdentifier, fFileList);
  1008.     
  1009. //        fi.Success();
  1010. //    }
  1011. //    else
  1012. //    {
  1013. //        this->SetValidationError(fi.error);
  1014. //        fi.ReSignal();
  1015. //    }
  1016. } // TODocCommand::DoIt 
  1017.  
  1018. //----------------------------------------------------------------------------------------
  1019. // TODocCommand::MakeAppleEvent: 
  1020. //----------------------------------------------------------------------------------------
  1021. #pragma segment MACommandRes
  1022.  
  1023. TAppleEvent* TODocCommand::MakeAppleEvent()
  1024. {
  1025.     MAVolatileInit(TAppleEvent*, mayFailEvent, NULL);
  1026.     CTempDesc theList;
  1027.  
  1028.     FailInfo fi;
  1029.     Try(fi)
  1030.     {
  1031.         TAppleEvent*    theEvent = new TAppleEvent;
  1032.         theEvent->IAppleEvent(kCoreEventClass, kAEOpenDocuments, gServerAddress, kAEWaitReply);
  1033.         mayFailEvent = theEvent;
  1034.         theList.CreateList();
  1035.         {
  1036.             CObjectIterator iter(fFileList);
  1037.             for (TFile * aFile = (TFile *)iter.FirstObject(); iter.More(); aFile = (TFile *)iter.NextObject())
  1038.             {
  1039.                 AliasHandle theAlias = NULL;
  1040.                 OSErr theErr = aFile->GetAlias(theAlias);
  1041.                 if (theErr == noErr)
  1042.                 {
  1043.                     CAEDesc theAliasDesc(typeAlias, (Handle)theAlias);
  1044.                     theList.PutListItem(0, theAliasDesc);
  1045.                 }
  1046.             }
  1047.         }
  1048.         theEvent->WriteParameter(keyDirectObject, theList);
  1049.         fi.Success();
  1050.     }
  1051.     else                                // Recover
  1052.     {
  1053.         mayFailEvent = (TAppleEvent *)FreeIfObject(mayFailEvent);
  1054.         fi.ReSignal();
  1055.     }
  1056.     return mayFailEvent;
  1057. }
  1058.  
  1059. //========================================================================================
  1060. // CLASS TPDocCommand
  1061. //========================================================================================
  1062. #undef Inherited
  1063. #define Inherited TFilesCommand
  1064.  
  1065. #pragma segment MASelCommand
  1066. MA_DEFINE_CLASS_M1(TPDocCommand, Inherited);
  1067.  
  1068. //----------------------------------------------------------------------------------------
  1069. // TPDocCommand constructor
  1070. //----------------------------------------------------------------------------------------
  1071. #pragma segment MASelCommand
  1072.  
  1073. TPDocCommand::TPDocCommand()
  1074. {
  1075.     fRequiresUserInteraction = TRUE;
  1076.     fTargetPrinter.name[0] = 0;            // no target printer
  1077. } // TPDocCommand::TPDocCommand
  1078.  
  1079. //----------------------------------------------------------------------------------------
  1080. // TPDocCommand destructor
  1081. //----------------------------------------------------------------------------------------
  1082. #pragma segment MADestructorRes
  1083.  
  1084. TPDocCommand::~TPDocCommand()
  1085. {
  1086. }
  1087.  
  1088. //----------------------------------------------------------------------------------------
  1089. // TPDocCommand::IPDocCommand: 
  1090. //----------------------------------------------------------------------------------------
  1091. #pragma segment MASelCommand
  1092.  
  1093. void TPDocCommand::IPDocCommand(CommandNumber itsCommandNumber,
  1094.                                 TList* theDocuments)
  1095. {
  1096.     this->IFilesCommand(itsCommandNumber, theDocuments);
  1097. } // TPDocCommand::IPDocCommand 
  1098.  
  1099. //----------------------------------------------------------------------------------------
  1100. // TPDocCommand::IPDocCommand: 
  1101. //----------------------------------------------------------------------------------------
  1102. #pragma segment MASelCommand
  1103.  
  1104. void TPDocCommand::IPDocCommand(CommandNumber itsCommandNumber,
  1105.                                 const AppleEvent& itsMessage,
  1106.                                 const AppleEvent& itsReply)
  1107. {
  1108.     Boolean draggedToDTP = FALSE;    // this will let us support cDragPrint
  1109.  
  1110.     AEDescList dtpList;
  1111.     OSErr err = AEGetAttributeDesc(&itsMessage, keyOptionalKeywordAttr, typeAEList, &dtpList);
  1112.     if (err == noErr)
  1113.     {
  1114.         draggedToDTP = TRUE;
  1115.         
  1116.         AEKeyword theKeyword;
  1117.         DescType typeCode;
  1118.         Size actualSize;
  1119.         
  1120.         OSErr err = AEGetNthPtr(&dtpList, 1, typeFSS, &theKeyword, &typeCode, (Ptr)&fTargetPrinter, sizeof(FSSpec), &actualSize);
  1121.         AEDisposeDesc(&dtpList);
  1122.     }
  1123.  
  1124.     this->IFilesCommand(draggedToDTP ? cDragPrint : itsCommandNumber, itsMessage, itsReply);
  1125. } // TPDocCommand::IPDocCommand 
  1126.  
  1127. //----------------------------------------------------------------------------------------
  1128. // TPDocCommand::DoIt: 
  1129. //----------------------------------------------------------------------------------------
  1130. #pragma segment MAFinder
  1131.  
  1132. void TPDocCommand::DoIt()                // override 
  1133. {
  1134.     gApplication->PrintDocuments(fIdentifier, fFileList, fTargetPrinter.name[0] ? &fTargetPrinter : NULL);
  1135. } // TPDocCommand::DoIt 
  1136.  
  1137.  
  1138. //========================================================================================
  1139. // CLASS TAboutBoxCommand
  1140. //========================================================================================
  1141. #undef Inherited
  1142. #define Inherited TCommand
  1143.  
  1144. #pragma segment MASelCommand
  1145. MA_DEFINE_CLASS_M1(TAboutBoxCommand, Inherited);
  1146.  
  1147. //----------------------------------------------------------------------------------------
  1148. // TAboutBoxCommand: Empty constructor to satisfy the compiler.
  1149. //----------------------------------------------------------------------------------------
  1150. #pragma segment ConstructorRes
  1151.  
  1152. TAboutBoxCommand::TAboutBoxCommand()
  1153. {
  1154. }
  1155.  
  1156. //----------------------------------------------------------------------------------------
  1157. // TAboutBoxCommand destructor
  1158. //----------------------------------------------------------------------------------------
  1159. #pragma segment MADestructorRes
  1160.  
  1161. TAboutBoxCommand::~TAboutBoxCommand()
  1162. {
  1163. }
  1164.  
  1165. //----------------------------------------------------------------------------------------
  1166. // TAboutBoxCommand::IAboutBoxCommand: 
  1167. //----------------------------------------------------------------------------------------
  1168. #pragma segment MASelCommand
  1169.  
  1170. void TAboutBoxCommand::IAboutBoxCommand(CommandNumber itsCommandNumber)
  1171. {
  1172.     this->ICommand(itsCommandNumber, gApplication, kCantUndo, kDoesNotCauseChange, NULL);
  1173.     FailOSErr(MAInteractWithUser());
  1174. } // TAboutBoxCommand::IAboutBoxCommand 
  1175.  
  1176. //----------------------------------------------------------------------------------------
  1177. // TAboutBoxCommand::DoIt: 
  1178. //----------------------------------------------------------------------------------------
  1179. #pragma segment MAAboutApp
  1180.  
  1181. void TAboutBoxCommand::DoIt()
  1182. {
  1183.     gApplication->DoAboutBox();
  1184. } // TAboutBoxCommand::DoIt 
  1185.  
  1186.  
  1187. //========================================================================================
  1188. // CLASS TEventRetrieverCommand
  1189. //========================================================================================
  1190.  
  1191. #if qNeedsVU
  1192.  
  1193. //========================================================================================
  1194. // CLASS TVUApplication
  1195. //========================================================================================
  1196. #undef Inherited
  1197. #define Inherited TDispatcher
  1198.  
  1199. #pragma segment MAInit
  1200. MA_DEFINE_CLASS_M1(TVUApplication, Inherited);
  1201.  
  1202. //----------------------------------------------------------------------------------------
  1203. // TVUApplication constructor 
  1204. //----------------------------------------------------------------------------------------
  1205. #pragma segment MAInit
  1206.  
  1207. TVUApplication::TVUApplication()
  1208. {
  1209. } // TVUApplication::TVUApplication
  1210.  
  1211. //----------------------------------------------------------------------------------------
  1212. // TVUApplication::IVUApplication: 
  1213. //----------------------------------------------------------------------------------------
  1214. #pragma segment MAInit
  1215.  
  1216. void TVUApplication::IVUApplication(OSType itsMainFileType,
  1217.                                     OSType itsCreator)
  1218. {
  1219.     this->IDispatcher(itsMainFileType, itsCreator);
  1220.  
  1221.     FailInfo fi;
  1222.     Try(fi)
  1223.     {
  1224.         gVUAssist = new TVUAssist();
  1225.         gVUAssist->IVUAssist(gUGridViewInitialized);
  1226.         fi.Success();
  1227.     }
  1228.     else
  1229.     {
  1230. #if qDebug
  1231.         ProgramBreak("Can't initialize the virtual user assist object!");
  1232. #endif
  1233.         this->Free();
  1234.         gVUAssist = NULL;
  1235.         // we don't fail if we have no VU support
  1236.         // Don't ReSignal
  1237.     }
  1238.  
  1239. } // TVUApplication::IVUApplication
  1240.  
  1241.  
  1242. //----------------------------------------------------------------------------------------
  1243. // TVUApplication::Free: 
  1244. //----------------------------------------------------------------------------------------
  1245. #pragma segment MAClose
  1246.  
  1247. TVUApplication::~TVUApplication()
  1248. {
  1249.     gVUAssist = (TVUAssist*)FreeIfObject(gVUAssist);
  1250. } // TVUApplication::Free 
  1251.  
  1252. //----------------------------------------------------------------------------------------
  1253. // TVUApplication::AboutToLoseControl: 
  1254. //----------------------------------------------------------------------------------------
  1255. #pragma segment MAActivate
  1256.  
  1257. void TVUApplication::AboutToLoseControl(Boolean)
  1258. {
  1259.     if (gVUAssist)
  1260.         gVUAssist->SuspendMole();
  1261. } // TVUApplication::AboutToLoseControl 
  1262.  
  1263. //----------------------------------------------------------------------------------------
  1264. // TVUApplication::RegainControl: 
  1265. //----------------------------------------------------------------------------------------
  1266. #pragma segment MAApplicationRes
  1267.  
  1268. void TVUApplication::RegainControl(Boolean)
  1269. {
  1270.     if (gVUAssist)
  1271.         gVUAssist->ResumeMole();
  1272. } // TVUApplication::RegainControl 
  1273.  
  1274. #endif
  1275.  
  1276. //========================================================================================
  1277. // CLASS TApplication
  1278. //========================================================================================
  1279. #undef Inherited
  1280.  
  1281. #if qNeedsVU
  1282. #define Inherited TVUApplication
  1283. #else
  1284. #define Inherited TDispatcher
  1285. #endif
  1286.  
  1287. #pragma segment MAInit
  1288. MA_DEFINE_CLASS_M1(TApplication, Inherited);
  1289.  
  1290. //----------------------------------------------------------------------------------------
  1291. // TApplication constructor 
  1292. //----------------------------------------------------------------------------------------
  1293. #pragma segment MAInit
  1294.  
  1295. TApplication::TApplication()
  1296. {
  1297.     // This is a special case.  It needs to be available as soon as possible.
  1298.     gApplication = this;
  1299.  
  1300.     fLaunchWithNewDocument = TRUE;
  1301.  
  1302. #if qDebug
  1303.     fDebugFlagsWindow = NULL;
  1304. #endif
  1305. } // TApplication::TApplication 
  1306.  
  1307. //----------------------------------------------------------------------------------------
  1308. // TApplication destructor
  1309. //----------------------------------------------------------------------------------------
  1310. #pragma segment MADestructorRes
  1311.  
  1312. TApplication::~TApplication()
  1313. {
  1314. }
  1315.  
  1316. //----------------------------------------------------------------------------------------
  1317. // TApplication::IApplication: 
  1318. //----------------------------------------------------------------------------------------
  1319. #pragma segment MAInit
  1320.  
  1321. void TApplication::IApplication(OSType itsMainFileType,
  1322.                                 OSType itsCreator)
  1323. {
  1324. #if qNeedsVU
  1325.     this->IVUApplication(itsMainFileType, itsCreator);
  1326. #else
  1327.     this->IDispatcher(itsMainFileType, itsCreator);
  1328. #endif
  1329.  
  1330.     FailInfo fi;
  1331.     Try(fi)
  1332.     {
  1333.         // Install the default tab  behavior 
  1334.         TMultiWindowTabber * aTabber = new TMultiWindowTabber;
  1335.         aTabber->IMultiWindowTabber(TRUE);
  1336.         this->AddBehavior(aTabber);
  1337.     
  1338.         {
  1339.             // Register views so we can create them from templates
  1340. #if qDebug
  1341.             MA_REGISTER_CLASS(TDebugFlagsView);
  1342. #endif
  1343.         }
  1344.  
  1345.         fi.Success();
  1346.     }
  1347.     else
  1348.     {
  1349. #if qDebug
  1350.         ProgramBreak("Can't initialize the application object!");
  1351. #endif
  1352.         this->Free();
  1353.         gApplication = NULL;
  1354.         fi.ReSignal();
  1355.     }
  1356. } // TApplication::IApplication 
  1357.  
  1358. //----------------------------------------------------------------------------------------
  1359. // TApplication::CanOpenDocument: 
  1360. //----------------------------------------------------------------------------------------
  1361. #pragma segment MAFinder
  1362.  
  1363. // This is called only when opening/printing from the finder and from standard file;
  1364. // it simulates the filtering done by Std File.
  1365.  
  1366. Boolean TApplication::CanOpenDocument(CommandNumber itsCommandNumber,
  1367.                                       TFile* aFile)
  1368. {
  1369.     Boolean returnValue = FALSE;
  1370.     
  1371.     ProcPtr fileFilter;
  1372.     TypeListHandle typeList = NULL;
  1373.     short dlgID;
  1374.     CPoint where;
  1375.     ProcPtr dlgHook;
  1376.     ProcPtr modalFilter;
  1377.     Ptr activeList;
  1378.     ProcPtr activateProc;
  1379.     void* yourDataPtr = NULL;
  1380.  
  1381.     this->GetStandardFileParameters(itsCommandNumber, fileFilter, typeList, dlgID, where,
  1382.                                     dlgHook, modalFilter, activeList, activateProc,
  1383.                                     NULL, yourDataPtr);
  1384.  
  1385.     CStr63 fileName;
  1386.     aFile->GetName(fileName);
  1387.  
  1388.     CInfoPBRec paramBlock;
  1389.  
  1390.     short numTypes = (short)(GetHandleSize((Handle)typeList) / sizeof(ResType));
  1391.     if (numTypes == 0)
  1392.     {
  1393.         if (!fileFilter)
  1394.             returnValue = TRUE;                    // no file filter then want all types
  1395.         else if (aFile->GetCatInfo(paramBlock) == noErr)
  1396.         {
  1397.             paramBlock.hFileInfo.ioNamePtr = (StringPtr)fileName;
  1398.             // Call through the supplied filterProc
  1399.             returnValue = !((FileFilterYDProcPtr)fileFilter)(¶mBlock, NULL);
  1400.         }
  1401.         else
  1402.             returnValue = FALSE;
  1403.     }
  1404.     else
  1405.     {
  1406.         for (short i = 0; i < numTypes; ++i)
  1407.         {
  1408.             if (((long)(aFile->fFileType)) == ((long)(*typeList)[i]))
  1409.             {
  1410.                 if (!fileFilter)
  1411.                     returnValue = TRUE;
  1412.                 else if (aFile->GetCatInfo(paramBlock) == noErr)
  1413.                 {
  1414.                     paramBlock.hFileInfo.ioNamePtr = (StringPtr)fileName;
  1415.                     // Call through the supplied filterProc
  1416.                     returnValue = !((FileFilterYDProcPtr)fileFilter)(¶mBlock, NULL);
  1417.                 }
  1418.                 else
  1419.                     returnValue = FALSE;
  1420.                 break;
  1421.             }
  1422.         }
  1423.     }
  1424.  
  1425.     typeList = (TypeListHandle)DisposeIfHandle((Handle)typeList);
  1426.     return returnValue;
  1427. } // TApplication::CanOpenDocument 
  1428.  
  1429. //----------------------------------------------------------------------------------------
  1430. // TApplication::ChooseApplication: 
  1431. //----------------------------------------------------------------------------------------
  1432. #pragma segment MAOpen
  1433.  
  1434. Boolean TApplication::ChooseApplication(AEAddressDesc& theAddress)
  1435. {
  1436.     //    typedef TargetID* TargetIDPtr,
  1437.     //    ** TargetIDHdl;
  1438.  
  1439.     TargetIDHdl theTargetID;
  1440.     LocationNameRec theLoc;
  1441.     PortInfoRec thePortInfo;
  1442.     OSErr theErr;
  1443.     CStr32 theLocNBPType;
  1444.     Boolean returnValue = FALSE;
  1445.  
  1446.     theErr = PPCBrowser(gEmptyString, gEmptyString, FALSE, &theLoc, &thePortInfo, NULL, gEmptyString);
  1447.     if (theErr == noErr)
  1448.     {
  1449.         theTargetID = (TargetIDHdl) NewPermHandle(sizeof(TargetID));
  1450.  
  1451.         (*theTargetID)->location = theLoc;
  1452.         (*theTargetID)->name = thePortInfo.name;
  1453.         theAddress.descriptorType = typeTargetID;
  1454.         theAddress.dataHandle = (Handle)theTargetID;
  1455.         returnValue = TRUE;
  1456.     }
  1457.     else if (theErr != userCanceledErr)
  1458.         FailOSErr(theErr);
  1459.     return returnValue;
  1460. } // TApplication::ChooseApplication 
  1461.  
  1462. //----------------------------------------------------------------------------------------
  1463. // TApplication::ChooseDocument: 
  1464. //----------------------------------------------------------------------------------------
  1465. #pragma segment MAOpen
  1466.  
  1467. Boolean TApplication::ChooseDocument(CommandNumber itsCommandNumber,
  1468.                                      TList** aFileList)
  1469. {
  1470.     typedef SFTypeList* SFTypeListPtr;
  1471.     typedef SFTypeListPtr* SFTypeListHandle;
  1472.  
  1473.     MAVolatileInit(TFile*, aFile, NULL);
  1474.     Boolean fileChosen;
  1475.  
  1476. #if !qPowerPC && !qModelCFM
  1477.     if (HasCustomFile())
  1478.     {
  1479. #endif
  1480.         ProcPtr fileFilter;
  1481.         TypeListHandle typeList;
  1482.         short dlgID;
  1483.         CPoint where;
  1484.         ProcPtr dlgHook;
  1485.         ProcPtr modalFilter;
  1486.         Ptr activeList;
  1487.         ProcPtr activateProc;
  1488.         StandardFileReply customReply;
  1489.         void* yourDataPtr = NULL;
  1490.         
  1491.         this->GetStandardFileParameters(itsCommandNumber, fileFilter, typeList, dlgID, where,
  1492.                                         dlgHook, modalFilter, activeList, activateProc,
  1493.                                         &customReply, yourDataPtr);
  1494.     
  1495.         SFTypeListPtr pTypeList;
  1496.         short numTypes = (short)(GetHandleSize((Handle)typeList) / sizeof(ResType));
  1497.         if (numTypes == 0)
  1498.         {
  1499.             numTypes = -1;                            // Tell Std File to display all types.
  1500.             pTypeList = (SFTypeListPtr) & pTypeList;// arbitrary, as long as it points to 4 bytes of valid memory
  1501.         }
  1502.         else
  1503.         {
  1504.             LockHandleHigh((Handle)typeList);        // in case Std File does allocations 
  1505.             pTypeList = *((SFTypeListHandle)typeList);
  1506.         }
  1507.     
  1508.         // Causes TApplication::GetEvent to call CheckRsrcUsage. 
  1509.         gRsrcCheck = 0;
  1510.     
  1511.         FailInfo fi;
  1512.         Try(fi)
  1513.         {
  1514.     
  1515.             aFile = this->DoMakeFile(itsCommandNumber);
  1516.             fileChosen = FALSE;
  1517.     
  1518.             FailOSErr(MAInteractWithUser()); 
  1519.     
  1520.             if (yourDataPtr == NULL)
  1521.                 yourDataPtr = &itsCommandNumber;
  1522.             
  1523.             gClipboardMgr->AboutToLoseControl(TRUE);            // so scrap gets converted
  1524.             
  1525.             FileFilterYDUPP cgfFileFilter = NewFileFilterYDProc(fileFilter);
  1526.             DlgHookYDUPP cgfDlgHook = NewDlgHookYDProc(dlgHook);
  1527.             ModalFilterYDUPP cgfModalFilter = NewModalFilterYDProc(modalFilter);
  1528.             ActivateYDUPP cgfActivateProc = NewActivateYDProc(activateProc);
  1529.  
  1530.             CustomGetFile(cgfFileFilter, numTypes, (*pTypeList), &customReply, dlgID, where, cgfDlgHook, cgfModalFilter, (short*)activeList, cgfActivateProc, yourDataPtr);
  1531.             
  1532.             cgfFileFilter = (FileFilterYDUPP)DisposeIfRoutineDescriptor((UniversalProcPtr)cgfFileFilter);
  1533.             cgfDlgHook = (DlgHookYDUPP)DisposeIfRoutineDescriptor((UniversalProcPtr)cgfDlgHook);
  1534.             cgfModalFilter = (ModalFilterYDUPP)DisposeIfRoutineDescriptor((UniversalProcPtr)cgfModalFilter);
  1535.             cgfActivateProc = (ActivateYDUPP)DisposeIfRoutineDescriptor((UniversalProcPtr)cgfActivateProc);
  1536.             
  1537.             gClipboardMgr->RegainControl(TRUE);            // so scrap gets converted
  1538.  
  1539.             fileChosen = customReply.sfGood;
  1540.             if (fileChosen)
  1541.                 aFile->SpecifyWithStandardFileReply(customReply);
  1542.     
  1543.             fi.Success();
  1544.         }
  1545.         else // Recover
  1546.         {
  1547.             typeList = (TypeListHandle)DisposeIfHandle((Handle)typeList);
  1548.             aFile = (TFile *)FreeIfObject(aFile);
  1549.             fi.ReSignal();
  1550.         }
  1551.     
  1552.         typeList = (TypeListHandle)DisposeIfHandle((Handle)typeList);
  1553.  
  1554.  
  1555.  
  1556. #if !qPowerPC && !qModelCFM
  1557.         // the following block of code is the "else" block for the above Gestalt check - 
  1558.         // as with that check, it is only relevant if we are not built for PowerPC
  1559.     }
  1560.     else
  1561.     {
  1562.         ProcPtr fileFilter;
  1563.         TypeListHandle typeList;
  1564.         short dlgID;
  1565.         CPoint where;
  1566.         ProcPtr dlgHook;
  1567.         ProcPtr modalFilter;
  1568.         Ptr activeList;
  1569.         ProcPtr activateProc;
  1570.         SFReply reply;
  1571.         void* yourDataPtr = NULL;
  1572.         
  1573.         // We can't pass reply because it's a lowly SFReply, not a StandardFileReply
  1574.         this->GetStandardFileParameters(itsCommandNumber, fileFilter, typeList, dlgID, where,
  1575.                                         dlgHook, modalFilter, activeList, activateProc,
  1576.                                         NULL, yourDataPtr);
  1577.     
  1578.         SFTypeListPtr pTypeList;
  1579.         short numTypes = (short)(GetHandleSize((Handle)typeList) / sizeof(ResType));
  1580.         if (numTypes == 0)
  1581.         {
  1582.             numTypes = -1;                            // Tell Std File to display all types.
  1583.             pTypeList = (SFTypeListPtr) & pTypeList;// arbitrary, as long as it points to 4 bytes of valid memory
  1584.         }
  1585.         else
  1586.         {
  1587.             LockHandleHigh((Handle)typeList);        // in case Std File does allocations 
  1588.             pTypeList = *((SFTypeListHandle)typeList);
  1589.         }
  1590.     
  1591.         // Causes TApplication::GetEvent to call CheckRsrcUsage. 
  1592.         gRsrcCheck = 0;
  1593.     
  1594.         FailInfo fi;
  1595.         Try(fi)
  1596.         {
  1597.     
  1598.             aFile = this->DoMakeFile(itsCommandNumber);
  1599.             fileChosen = FALSE;
  1600.     
  1601.             FailOSErr(MAInteractWithUser()); 
  1602.     
  1603.             if (yourDataPtr == NULL)
  1604.                 yourDataPtr = &itsCommandNumber;
  1605.             
  1606.             // We will pass the address of the CallBack instead of the modalFilter to
  1607.             // SFPGetFile It will add yourDataPtr parameter before passing on to the
  1608.             // ModalFilterProc supplied by SFPutParms this lets us assume a single calling
  1609.             // convention for that function.
  1610.  
  1611.             // Don't create a CallBack when the SF callback is NULL.
  1612.             // Also, pass itsCommandNumber as a default yourDataPtr.
  1613.             
  1614.             CallBack myFileFilterCallBack;
  1615.             SetCallBack(fileFilter, (long)yourDataPtr, &myFileFilterCallBack);
  1616.             FileFilterProcPtr aFileFilterProcPtr = fileFilter ? (FileFilterProcPtr)&myFileFilterCallBack : NULL;
  1617.  
  1618.             CallBack myModalHookCallBack;
  1619.             SetCallBack(dlgHook, (long)yourDataPtr, &myModalHookCallBack);
  1620.             DlgHookProcPtr aDlgHookProcPtr = dlgHook ? (DlgHookProcPtr)&myModalHookCallBack : NULL;
  1621.     
  1622.             CallBack myModalFilterCallBack;
  1623.             SetCallBack(modalFilter, (long)yourDataPtr, &myModalFilterCallBack);
  1624.             ModalFilterProcPtr aModalFilterProcPtr = modalFilter ? (ModalFilterProcPtr)&myModalFilterCallBack : NULL;
  1625.  
  1626.             gClipboardMgr->AboutToLoseControl(TRUE);    // so scrap gets converted
  1627.  
  1628.             SFPGetFile(where, gEmptyString, aFileFilterProcPtr, numTypes, (*pTypeList), aDlgHookProcPtr, &reply, dlgID, aModalFilterProcPtr);
  1629.             
  1630.             gClipboardMgr->RegainControl(TRUE);            // so scrap gets converted
  1631.  
  1632.             fileChosen = reply.good;
  1633.             if (fileChosen)
  1634.                 FailOSErr(aFile->SpecifyWithSFReply(reply));
  1635.             
  1636.             fi.Success();
  1637.         }
  1638.         else // Recover
  1639.         {
  1640.             typeList = (TypeListHandle)DisposeIfHandle((Handle)typeList);
  1641.             aFile = (TFile *)FreeIfObject(aFile);
  1642.             fi.ReSignal();
  1643.         }
  1644.     
  1645.         typeList = (TypeListHandle)DisposeIfHandle((Handle)typeList);
  1646.  
  1647.     }
  1648. #endif
  1649.  
  1650.     if (fileChosen)
  1651.     {
  1652.         MAVolatileInit(TList**, volatileFileList, aFileList);
  1653.         
  1654.         FailInfo fi;
  1655.         Try(fi)
  1656.         {
  1657.             // Return the file(s) chosen 
  1658.             *volatileFileList = NewList();
  1659.             (*volatileFileList)->InsertLast(aFile);
  1660.             fi.Success();
  1661.         }
  1662.         else
  1663.         {
  1664.             if (*volatileFileList)
  1665.                 *volatileFileList = (TList*)FreeIfObject(*volatileFileList);
  1666.             aFile = (TFile*)FreeIfObject(aFile);
  1667.             fi.ReSignal();
  1668.         }
  1669.     }
  1670.     else                                        // user cancelled or something 
  1671.         aFile = (TFile *)(FreeIfObject(aFile));    // free the unwanted file object 
  1672.     
  1673.     return fileChosen;
  1674. } // TApplication::ChooseDocument 
  1675.  
  1676. //----------------------------------------------------------------------------------------
  1677. // TApplication::DoMakeDocument: 
  1678. //
  1679. // E X A M P L E
  1680. // {
  1681. //         TDocument*    aYOURDocument = NULL;
  1682. //
  1683. //         aYOURDocument = new TDocument;
  1684. //         aYOURDocument->IYOURDocument();
  1685. //        return aYOURDocument;
  1686. // }
  1687. //----------------------------------------------------------------------------------------
  1688. #pragma segment MANever
  1689.  
  1690. TDocument* TApplication::DoMakeDocument(CommandNumber, TFile*)
  1691. {
  1692.     this->SubClassResponsibility();
  1693.     return NULL;                                // So that CFront doesn't complain
  1694. } // TApplication::DoMakeDocument 
  1695.  
  1696. //----------------------------------------------------------------------------------------
  1697. // TApplication::DoMenuCommand: 
  1698. //----------------------------------------------------------------------------------------
  1699. #pragma segment MASelCommand
  1700.  
  1701. void TApplication::DoMenuCommand(CommandNumber aCommandNumber)
  1702. {
  1703.     // ===================================================================================
  1704.     // Some commands will be posted to perform actions that must _ALWAYS_ be available.
  1705.     // The allocation cannot be allowed to fail. So we do a temp allocation which by
  1706.     // definition cannot be allowed to fail. This strategy is used wherever we want to use
  1707.     // command objects but don't want to leave the user twisting in the breeze. NOTE:
  1708.     // Don't forget to allow for this memory in your mem! resource if you copy this style
  1709.     // in your own code.
  1710.     // ===================================================================================
  1711.  
  1712.     switch (aCommandNumber)
  1713.     {
  1714.         case cQuit:
  1715.             {
  1716.                 Boolean oldTempAlloc = TemporaryAllocation(TRUE);
  1717.                 Boolean oldObjectPerm = AllocateObjectsFromPerm(FALSE);
  1718.                 TQuitCommand * aQuitCommand;
  1719.                 aQuitCommand = new TQuitCommand;
  1720.                 aQuitCommand->IQuitCommand(aCommandNumber);
  1721.                 this->PostCommand(aQuitCommand);
  1722.                 TemporaryAllocation(oldTempAlloc);
  1723.                 AllocateObjectsFromPerm(oldObjectPerm);
  1724.             }
  1725.             break;
  1726.  
  1727.         case cNew:                                // cNew..cNewLast:
  1728.         case 11:
  1729.         case 12:
  1730.         case 13:
  1731.         case 14:
  1732.         case 15:
  1733.         case 16:
  1734.         case 17:
  1735.         case 18:
  1736.         case cNewLast:
  1737.         case cFinderNew:
  1738.             this->DoNew(aCommandNumber);
  1739.             break;
  1740.  
  1741.         case cOpen:                                // cOpen..cOpenLast:
  1742.         case 21:
  1743.         case 22:
  1744.         case 23:
  1745.         case 24:
  1746.         case 25:
  1747.         case 26:
  1748.         case 27:
  1749.         case 28:
  1750.         case cOpenLast:
  1751.             this->DoOpen(aCommandNumber);
  1752.             break;
  1753.  
  1754.         case cAboutApp:
  1755.             {
  1756.                 TAboutBoxCommand * aAboutAppCommand = new TAboutBoxCommand;
  1757.                 aAboutAppCommand->IAboutBoxCommand(aCommandNumber);
  1758.                 this->PostCommand(aAboutAppCommand);
  1759.             }
  1760.             break;
  1761.  
  1762. #if qDebug
  1763.         case cDebugFlags:
  1764.             {
  1765.                 if (!fDebugFlagsWindow)
  1766.                     FailNIL(fDebugFlagsWindow = gViewServer->NewTemplateWindow(kDebugFlagsView, NULL));
  1767.                 fDebugFlagsWindow->Open();
  1768.                 fDebugFlagsWindow->Select();
  1769.             }
  1770.             break;
  1771.  
  1772.         case cRefreshFrontWindow:
  1773.             {
  1774.                 TWindow * aWindow = this->GetActiveWindow(kNoFloaters);
  1775.  
  1776.                 if (aWindow)
  1777.                     aWindow->ForceRedraw();
  1778.             }
  1779.             break;
  1780.  
  1781.         case cDoFirstClick:
  1782.             {
  1783.                 TWindow * aWindow = this->GetActiveWindow(kNoFloaters);
  1784.  
  1785.                 if (aWindow)
  1786.                     aWindow->fDoFirstClick = !aWindow->fDoFirstClick;
  1787.             }
  1788.             break;
  1789.  
  1790.         // System Justification - see comment in Debug.r
  1791.     //    case cSetSysJust:
  1792.             // swap the current setting 
  1793.     //        if (GetSysDirection() == smSysJustLeft)
  1794.     //            SetSysDirection(smSysJustRight);
  1795.     //        else
  1796.     //            SetSysDirection(smSysJustLeft);
  1797.     //        break;
  1798. #endif
  1799.  
  1800. #if qPerform
  1801.         case cPerfMonInit:
  1802.             {
  1803.                 TWindow* aWindow;
  1804.                 IDType dismisser;
  1805.                 
  1806.                 FailNIL(aWindow = gViewServer->NewTemplateWindow(kPerfMonInitView, NULL));
  1807.                 dismisser = aWindow->PoseModally();
  1808.                 if (dismisser == 'init')
  1809.                     InitiatePerfMonitor(aWindow);
  1810.                 aWindow->CloseAndFree();
  1811.             }
  1812.             break;
  1813.             
  1814.         case cPerfMonDump:
  1815.             {
  1816.                 StandardFileReply replyRec;
  1817.                 StandardPutFile((StringPtr)"\pSave as:", (StringPtr)"\puntitled", &replyRec);
  1818.                 if (replyRec.sfGood)
  1819.                     DumpPerfMonitor(replyRec.sfFile);
  1820.             }
  1821.             break;                
  1822.             
  1823.         case cPerfMonToggle:
  1824.             EnablePerfMonitor(!PerfMonitorEnabled());
  1825.             break;
  1826.             
  1827.         case cPerfMonEnd:
  1828.             TerminatePerfMonitor();
  1829.             break;
  1830. #endif
  1831.             
  1832.         default:
  1833.             Inherited::DoMenuCommand(aCommandNumber);
  1834.             break;
  1835.     }
  1836. } // TApplication::DoMenuCommand 
  1837.  
  1838. //----------------------------------------------------------------------------------------
  1839. // TApplication::DoSetupMenus: 
  1840. //----------------------------------------------------------------------------------------
  1841. #pragma segment MAApplicationRes
  1842.  
  1843. void TApplication::DoSetupMenus()
  1844. {
  1845.     Inherited::DoSetupMenus();
  1846.  
  1847.     Boolean lowSpace = MemSpaceIsLow();
  1848.  
  1849.     Enable(cAboutApp, TRUE);
  1850.     Enable(-(mApple << 8), TRUE);    // allow the whole menu
  1851.  
  1852.     Enable(cQuit, fEventLevel <= 1);    // Can't enable Quit if in nested event handling
  1853.     Enable(cNew, !lowSpace);
  1854.     Enable(cOpen, !lowSpace);
  1855.  
  1856. #if qDebug
  1857.     {
  1858.         TWindow* aWindow = gApplication->GetActiveWindow(kNoFloaters);
  1859.  
  1860.         Enable(cRefreshFrontWindow, (aWindow != NULL));
  1861.         Enable(cDoFirstClick, (aWindow != NULL));
  1862.         if (aWindow)
  1863.             SetMenuState(cDoFirstClick, kDebugBuzzStrings, bzDoFirstClick, bzDontDoFirstClick, aWindow->fDoFirstClick);
  1864.  
  1865.         Enable(cDebugFlags, TRUE);
  1866.  
  1867.         // System Justification - see comment in Debug.r
  1868.         //    Enable(cSetSysJust, TRUE);
  1869.         //    SetMenuState(cSetSysJust, kDebugBuzzStrings, bzSetRightSysJust, bzSetLeftSysJust, GetSysDirection() != smSysJustLeft);
  1870.     }
  1871. #endif
  1872.  
  1873. #if qPerform
  1874.     {
  1875.         Boolean initiated = PerfMonitorInitiated();
  1876.         
  1877.         Enable(cPerfMonInit, !initiated);
  1878.         Enable(cPerfMonDump, initiated);
  1879.         Enable(cPerfMonToggle, initiated);
  1880.         SetMenuState(cPerfMonToggle, kDebugBuzzStrings, bzContinuePerfMon, bzPausePerfMon, PerfMonitorEnabled());
  1881.         Enable(cPerfMonEnd, initiated);
  1882.     }
  1883. #endif
  1884.  
  1885. } // TApplication::DoSetupMenus 
  1886.  
  1887. //----------------------------------------------------------------------------------------
  1888. // TApplication::DoAboutBox: Method to display the "About" box for your application.
  1889. // Override to do interesting things. Since it is normally called from a command; the app
  1890. // usually has the maximum free space available.
  1891. //----------------------------------------------------------------------------------------
  1892. #pragma segment MAAboutApp
  1893.  
  1894. void TApplication::DoAboutBox()
  1895. {
  1896.     FailSpaceIsLow();
  1897.     FailOSErr(MAInteractWithUser());
  1898.  
  1899.     CStr255 apName;
  1900.     this->GetApplicationName(apName);
  1901.  
  1902.     ParamText(apName, gEmptyString, gEmptyString, gEmptyString);                // Put Application name in the about box 
  1903.  
  1904.     if (GetResource('STR#', kDefaultCredits))
  1905.     {
  1906.         lastCreditsStringIndex = 1;
  1907.         lastCreditsShownTicks = TickCount();
  1908.         waitTicks = 5 * 60;
  1909.         originalText = (CStringHandle)NewString(gEmptyString);
  1910.         FailNIL(originalText);
  1911.         MacAppAlert(phAboutApp, (ProcPtr)DoShowAboutAppFilter);
  1912.         originalText = (CStringHandle)DisposeIfHandle((Handle)originalText);
  1913.     }
  1914.     else
  1915.         StdAlert(phAboutApp);
  1916. } // TApplication::DoAboutBox 
  1917.  
  1918. //----------------------------------------------------------------------------------------
  1919. // TApplication::HandleFinderRequest: 
  1920. //----------------------------------------------------------------------------------------
  1921. #pragma segment MAFinder
  1922.  
  1923. void TApplication::HandleFinderRequest()
  1924. {
  1925. } // TApplication::HandleFinderRequest 
  1926.  
  1927. //----------------------------------------------------------------------------------------
  1928. // TApplication::KindOfDocument: 
  1929. //----------------------------------------------------------------------------------------
  1930. #pragma segment MAOpen
  1931.  
  1932. CommandNumber TApplication::KindOfDocument(CommandNumber itsCommandNumber,
  1933.                                                   TFile*)
  1934. {
  1935.     return itsCommandNumber;
  1936. } // TApplication::KindOfDocument 
  1937.  
  1938. //----------------------------------------------------------------------------------------
  1939. // TApplication::OpenNew: 
  1940. //----------------------------------------------------------------------------------------
  1941. #pragma segment MAOpen
  1942.  
  1943. TDocument* TApplication::OpenNew(CommandNumber itsCommandNumber)
  1944. {
  1945.     MAVolatileInit(TDocument*, aDocument, NULL);
  1946.  
  1947.     FailInfo fi;
  1948.     Try(fi)
  1949.     {
  1950.         FailNIL(aDocument = this->DoMakeDocument(this->KindOfDocument(itsCommandNumber, NULL), NULL));
  1951.         aDocument->DoInitialState();
  1952.  
  1953.         aDocument->DoMakeViews(kForDisplay);
  1954.  
  1955.         CStr255 newTitle;
  1956.         aDocument->UntitledName(newTitle);
  1957.         aDocument->SetTitle(newTitle);
  1958.  
  1959.         FailSpaceIsLow();                        // Fail if document leaves us with no room 
  1960.  
  1961.         // Don't attempt to show the windows until we're sure we won't fail 
  1962.         aDocument->DoPostMakeViews(kForDisplay);
  1963.  
  1964.         fi.Success();
  1965.     }
  1966.     else // Recover
  1967.     {
  1968.         if (aDocument)
  1969.             aDocument = (TDocument *)(FreeIfObject(aDocument));    // The document will free the file
  1970.  
  1971.         FailNewMessage(fi.error, fi.message, messageNewFailed);
  1972.     }
  1973.     return aDocument;
  1974. } // TApplication::OpenNew 
  1975.  
  1976. //----------------------------------------------------------------------------------------
  1977. // TApplication::OpenOld: 
  1978. //----------------------------------------------------------------------------------------
  1979. #pragma segment MAOpen
  1980.  
  1981. TDocument* TApplication::OpenOld(CommandNumber itsOpenCommand, TList* aFileList)
  1982. {
  1983.     MAVolatileInit(TDocument*, aDocument, NULL);
  1984.     MAVolatileInit(TFile*, aFile, NULL);
  1985.     MAVolatileInit(TFile*, aNewFile, NULL);
  1986.     MAVolatileInit(OSErr, savedError, 0);
  1987.     MAVolatileInit(long, savedMessage, 0);
  1988.     
  1989.     Size oldCodeReserve;    // can't be volatile because it is passed by reference
  1990.     Size oldMemReserve;        // can't be volatile because it is passed by reference
  1991.  
  1992.     {
  1993.         // Put iterator in a separate block so that it will go out of scope before the end of the method.
  1994.         // We don't want the iterator's failure handler to be invoked, because its stack ptr is munged.
  1995.         // If an error occurs, we'll just save it and ReSignal it after the iterator is gone.
  1996.         
  1997.         CObjectIterator iter(aFileList);
  1998.         for (aFile = (TFile *)iter.FirstObject(); iter.More() && !savedError; aFile = (TFile *)iter.NextObject())
  1999.         {
  2000.             CommandNumber kindOfDocCmd = this->KindOfDocument(itsOpenCommand, aFile);
  2001.             // reset aDocument and aNewFile so that they no longer refer to items from the
  2002.             // last go round (important in case we fail downstream)…
  2003.             aDocument = NULL;
  2004.             aNewFile = NULL;
  2005.             
  2006.             CStr63 fileName;
  2007.             aFile->GetName(fileName);            // If failure occurs the file may already be
  2008.                                                 // freed so we will save the name just in
  2009.                                                 // case.
  2010.             
  2011.             aFileList->Delete(aFile);            // ReadStationery if successful will dispose
  2012.                                                 // of the file for us so if failure occurs
  2013.                                                 // this had better not be in the file list.
  2014.             
  2015.             FailInfo fi;
  2016.             Try(fi)
  2017.             {
  2018.                 // Set reserve down a little to ensure that we can open existing documents 
  2019.                 GetReserveSize(oldCodeReserve, oldMemReserve);
  2020.                 SetReserveSize(oldCodeReserve, oldMemReserve / 2);
  2021.                 
  2022.                 TDocument * otherDoc = this->FindDocument(aFile);
  2023.                 Boolean isStationery = aFile->IsStationery();
  2024.                 
  2025.                 if (otherDoc && !isStationery)
  2026.                 {
  2027.                     otherDoc->OpenAgain(kindOfDocCmd, aDocument);
  2028.                     aFile = (TFile*)FreeIfObject(aFile);
  2029.                     SetReserveSize(oldCodeReserve, oldMemReserve);
  2030.                 }
  2031.                 else if (this->CanOpenDocument(kindOfDocCmd, aFile))
  2032.                 {
  2033.                     TFile* fileOwnedByDoc = aFile;
  2034.                     aFile = NULL;
  2035.                     FailNIL(aDocument = this->DoMakeDocument(kindOfDocCmd, fileOwnedByDoc));
  2036.  
  2037.                     if (!isStationery)
  2038.                         aDocument->ReadDocument(kForDisplay);
  2039.                     else
  2040.                     {
  2041.                         aNewFile = this->DoMakeFile(kindOfDocCmd);
  2042.                         aDocument->ReadStationery(aNewFile);
  2043.                         aFile = NULL;                // This file has already been freed by ReadStationery.
  2044.                         aNewFile = NULL;            // Clear our reference so that if we fail
  2045.                                                     // we don't try to free this file twice.
  2046.                     }
  2047.                     
  2048.                     aDocument->DoMakeViews(kForDisplay);
  2049.     
  2050.                     if (isStationery)
  2051.                     {
  2052.                         CStr255 newTitle;
  2053.                         aDocument->UntitledName(newTitle);
  2054.                         aDocument->SetTitle(newTitle);
  2055.                     }
  2056.         
  2057.                     FailSpaceIsLow();                // Fail if the document leaves us with no
  2058.                                                     // memory
  2059.                     // Set the reserve back to where it was 
  2060.                     SetReserveSize(oldCodeReserve, oldMemReserve);
  2061.         
  2062.                     // Don't attempt to show the windows until we're sure we won't fail 
  2063.                     aDocument->DoPostMakeViews(kForDisplay);
  2064.                 }
  2065.                 else
  2066.                     Failure(errNotMyType, 0);
  2067.                 fi.Success();
  2068.             }
  2069.             else // Recover
  2070.             {
  2071.                 if (fi.message == 0)
  2072.                     gErrorParm3 = fileName;
  2073.                     
  2074.                 // We may have ended up without a document because of a failure during document
  2075.                 // init. b/c this can be the case we don't know what happened to aFile, whether 
  2076.                 // it was freed by the document in the failure process or orphaned. Because of
  2077.                 // this we will not free aFile here.
  2078.                 if (aDocument)
  2079.                     aDocument = (TDocument *)(FreeIfObject(aDocument));    // The document will free the file
  2080.                     
  2081.                 aNewFile = (TFile*)FreeIfObject(aNewFile);                // If we successfully read the
  2082.                                                                         // stationery then aNewFile will be NULL
  2083.                 
  2084.                 // Set the reserve back to where it was 
  2085.                 SetReserveSize(oldCodeReserve, oldMemReserve);
  2086.                 
  2087.                 //    Don't want to fail here, because the CObjectIterator (with its embedded FailInfo) is 
  2088.                 //    still in scope. Instead, save the error info until after the iterator has self-destructed.
  2089.                 //    FailNewMessage(fi.error, fi.message, messageOpenFailed);
  2090.                 savedError = fi.error;
  2091.                 savedMessage = fi.message;
  2092.                 if (!savedMessage)
  2093.                     savedMessage = messageOpenFailed;
  2094.             }
  2095.         }
  2096.     } // iterator will self-destruct now
  2097.  
  2098.       if (savedError != noErr)                        // Do we need to ReSignal a failure?
  2099.     {
  2100.         // signal the failure
  2101.         Failure(savedError, savedMessage);
  2102.     }
  2103.     return aDocument;
  2104. } // TApplication::OpenOld 
  2105.  
  2106. //----------------------------------------------------------------------------------------
  2107. // TApplication::PrintDocuments: 
  2108. //----------------------------------------------------------------------------------------
  2109. #pragma segment MAFinder
  2110.  
  2111. void TApplication::PrintDocuments(CommandNumber itsCommandNumber, TList* aFileList, const FSSpec* targetPrinter)
  2112. {
  2113.     MAVolatileInit(TDocument*, aDocument, NULL);
  2114.     MAVolatileInit(TFile*, aFile, NULL);
  2115.  
  2116.     TPrintHandler::gFinderPrintingProceed = TRUE;            // set in TStdPrintHandler::DoPrintCommand
  2117.     TPrintHandler::gPrintHandler->PrepareForFinderPrinting(targetPrinter);
  2118.  
  2119.     CObjectIterator iter(aFileList);
  2120.     for (aFile = (TFile *)iter.FirstObject(); iter.More(); aFile = (TFile *)iter.NextObject())
  2121.     {
  2122.         if (TPrintHandler::gFinderPrintingProceed)
  2123.         {
  2124.             FailInfo fi;
  2125.             Try(fi)
  2126.             {
  2127.                 FailNIL(aDocument = this->DoMakeDocument(this->KindOfDocument(itsCommandNumber, aFile), aFile));
  2128.                 aDocument->ReadDocument(kForPrinting);
  2129.                 aDocument->DoMakeViews(kForPrinting);
  2130.                 aDocument->DoPostMakeViews(kForPrinting);
  2131.  
  2132.                 aDocument->HandleMenuCommand(itsCommandNumber);
  2133.  
  2134.                 fi.Success();
  2135.             }
  2136.             else // Recover
  2137.             {
  2138.                 if (aDocument)
  2139.                 {
  2140.                     // If there is a document then it will have a reference to aFile and
  2141.                     // will free it when it is freed. Therefore we need to remove it from
  2142.                     // the list so that when the file list is freed we don't attempt to
  2143.                     // free it twice.
  2144.                     aFileList->Delete(aFile);
  2145.                     aDocument = (TDocument *)FreeIfObject(aDocument);
  2146.                 }
  2147.                 fi.ReSignal();
  2148.             }
  2149.             aFileList->Delete(aFile);
  2150.             aDocument = (TDocument *)FreeIfObject(aDocument);
  2151.         }
  2152.         else
  2153.             break;                                // The user canceled printing
  2154.     }
  2155. } // TApplication::PrintDocuments 
  2156.  
  2157. //----------------------------------------------------------------------------------------
  2158. // TApplication::GetStandardFileParameters: 
  2159. //----------------------------------------------------------------------------------------
  2160. #pragma segment MAOpen
  2161.  
  2162. void TApplication::GetStandardFileParameters(CommandNumber itsCommandNumber,
  2163.                                              ProcPtr& fileFilter,
  2164.                                              TypeListHandle& typeList,
  2165.                                              short& dlgID,
  2166.                                              CPoint& where,
  2167.                                              ProcPtr& dlgHook,
  2168.                                              ProcPtr& modalFilter,
  2169.                                              Ptr& activeList,
  2170.                                              ProcPtr& activateProc,
  2171.                                              StandardFileReply* /*reply*/,
  2172.                                              void*& yourDataPtr)
  2173. {
  2174.     dlgID = sfGetDialogID;
  2175.     where = kBestSystemLocation;
  2176.  
  2177.     this->GetFileTypeList(itsCommandNumber, typeList);
  2178.  
  2179.     fileFilter = NULL;
  2180.     dlgHook = NULL;
  2181.     modalFilter = (ProcPtr)gModalFilterYDProcPtr;
  2182.     activeList = NULL;
  2183.     activateProc = NULL;
  2184.     yourDataPtr = NULL;
  2185. } // TApplication::GetStandardFileParameters 
  2186.  
  2187. //----------------------------------------------------------------------------------------
  2188. // TApplication::GetFileTypeList: 
  2189. //----------------------------------------------------------------------------------------
  2190. #pragma segment MAOpen
  2191.  
  2192. void TApplication::GetFileTypeList(CommandNumber,
  2193.                                    TypeListHandle& typeList)
  2194. {
  2195.     typeList = (TypeListHandle) NewPermHandle(4);
  2196.     (*typeList)[0] = fMainFileType;
  2197. } // TApplication::GetFileTypeList 
  2198.  
  2199. //----------------------------------------------------------------------------------------
  2200. // TApplication::DoNew: 
  2201. //----------------------------------------------------------------------------------------
  2202. #pragma segment MAScriptingRes
  2203.  
  2204. void TApplication::DoNew(CommandNumber theCmdNumber)
  2205. {
  2206.     TNewDocumentCommand *aNewDocCommand = new TNewDocumentCommand;
  2207.     aNewDocCommand->INewDocumentCommand(theCmdNumber);
  2208.     aNewDocCommand->fUseAppleEvent = TRUE;
  2209.     this->PostCommand(aNewDocCommand);
  2210. }
  2211.  
  2212. //----------------------------------------------------------------------------------------
  2213. // TApplication::DoOpen: 
  2214. //----------------------------------------------------------------------------------------
  2215. #pragma segment MAScriptingRes
  2216.  
  2217. void TApplication::DoOpen(CommandNumber theCmdNumber)
  2218. {
  2219.     TList* aFileList = NULL;    // passed by address
  2220.  
  2221.     if (this->ChooseDocument(theCmdNumber, &aFileList))
  2222.     {
  2223.         TODocCommand * anODocCommand = new TODocCommand;
  2224.         anODocCommand->IODocCommand(theCmdNumber, aFileList);
  2225.         anODocCommand->fUseAppleEvent = TRUE;
  2226.         this->PostCommand(anODocCommand);
  2227.     }
  2228. }
  2229.  
  2230. //----------------------------------------------------------------------------------------
  2231. // TApplication::DoAECreateElement: 
  2232. //----------------------------------------------------------------------------------------
  2233. #pragma segment MAScriptingRes
  2234.  
  2235. void TApplication::DoAECreateElement(TAppleEvent* message,
  2236.                                      TAppleEvent* reply)
  2237. {
  2238.     // Creates a new document. If your application has more than one type of document
  2239.     // you'll need to override this method. The default simulates choosing "New" from
  2240.     // the file menu.
  2241.     DescType theClass = message->ReadType(keyAEObjectClass);
  2242.     if (IsDocumentClass(theClass) || (theClass == cWindow))
  2243.     {
  2244.         if (CommandEnabled(cNew))
  2245.         {
  2246.             TDocument * theDoc = this->OpenNew(cNew);
  2247.             // Apply the properties if any.
  2248.             theDoc->SetPropertiesFromEvent(message);
  2249.             
  2250.             // Apply the initial data if any
  2251.             if (message->HasParameter(keyAEData))
  2252.                 theDoc->DoAESetData(message, reply);
  2253.  
  2254.             // Return the document's object specifier
  2255.             CTempDesc theDocsSpecifier;
  2256.             theDoc->MakeObjectSpecifier(theDocsSpecifier, formName);
  2257.             if (reply->fMessage.dataHandle)
  2258.                 reply->WriteParameter(keyAEResult, theDocsSpecifier);
  2259.         }
  2260.     }
  2261. }
  2262.  
  2263. //----------------------------------------------------------------------------------------
  2264. // TApplication::DoAEClose: 
  2265. //----------------------------------------------------------------------------------------
  2266. #pragma segment MAScriptingRes
  2267.  
  2268. void TApplication::DoAEClose(TAppleEvent* message,
  2269.                              TAppleEvent* reply)
  2270. {
  2271.     if (CommandEnabled(cQuit))
  2272.     {
  2273.         Boolean oldTempAlloc = TemporaryAllocation(TRUE);
  2274.         Boolean oldObjectPerm = AllocateObjectsFromPerm(FALSE);
  2275.         TQuitCommand* quitCommand = NULL;
  2276.         Boolean quitIsBeingProcessed = TRUE;
  2277.  
  2278.         quitCommand = new TQuitCommand;
  2279.         quitCommand->IQuitCommand(message, reply, &quitIsBeingProcessed);
  2280.  
  2281.         quitCommand->Process();
  2282.  
  2283.         TemporaryAllocation(oldTempAlloc);
  2284.         AllocateObjectsFromPerm(oldObjectPerm);
  2285.     }
  2286. }
  2287.  
  2288. //----------------------------------------------------------------------------------------
  2289. // TApplication::DoScriptCommand: 
  2290. //----------------------------------------------------------------------------------------
  2291. #pragma segment MAScriptingRes
  2292.  
  2293. void TApplication::DoScriptCommand(CommandNumber    aCommandNumber,
  2294.                                     TAppleEvent*     message,
  2295.                                        TAppleEvent*     reply)
  2296. {
  2297.     TEventHandler * theTarget = this->GetTarget();
  2298.  
  2299.     switch (aCommandNumber)
  2300.     {
  2301.         case cFinderNew:
  2302.             // Special case the old MacPaint style open if user knows about the option
  2303.             // key. Only if the application is frontmost though.
  2304.             if (this->IsFrontProcess() && IsOptionKeyDown())
  2305.                 this->HandleMenuCommand(cOpen);
  2306.             else if (fLaunchWithNewDocument)
  2307.                 this->GetTarget()->HandleMenuCommand(cFinderNew);
  2308.             break;
  2309.  
  2310.         case cFinderOpen:
  2311.             {
  2312.                 TODocCommand * anODocCommand = new TODocCommand;
  2313.                 anODocCommand->IODocCommand(aCommandNumber, message->fMessage, reply->fMessage);
  2314.                 this->PostCommand(anODocCommand);
  2315.             }
  2316.             break;
  2317.  
  2318.         case cFinderPrint:
  2319.         case cDragPrint:
  2320.             {
  2321.                 TPDocCommand * aPDocCommand = new TPDocCommand;
  2322.                 aPDocCommand->IPDocCommand(aCommandNumber, message->fMessage, reply->fMessage);
  2323.                 this->PostCommand(aPDocCommand);
  2324.             }
  2325.             break;
  2326.             
  2327.         case cSectionRead:
  2328.         case cSectionWrite:
  2329.         case cSectionScroll:
  2330.         case cSectionCancel:
  2331.             {
  2332.                 TSectionMgr* aSectionMgr = (TSectionMgr*) this->GetBehaviorWithIdentifier(kSectionMgrBehaviorID);
  2333.                 aSectionMgr->DoAESectionEvent(aCommandNumber, message->fMessage, reply->fMessage);
  2334.             }
  2335.             break;
  2336.  
  2337.         default:
  2338.             //MDefaultScriptableObject::DoScriptCommand(aCommandNumber, message, reply);
  2339.             Inherited::DoScriptCommand(aCommandNumber, message, reply);
  2340.             break;
  2341.     }
  2342. }
  2343.  
  2344. //----------------------------------------------------------------------------------------
  2345. // End of UApplication.cp 
  2346.  
  2347. #pragma segment Inline
  2348.